package set

import "sync"

var _ Set[int] = NewSafeSet[int]()

// SafeSet 定义基于 sync.RWMute 的并发安全的集合
type SafeSet[T comparable] struct {
	set  *UnsafeSet[T]
	lock sync.RWMutex
}

// NewSafeSet 新建一个基于 sync.RWMute 的并发安全的集合
func NewSafeSet[T comparable](elems ...T) *SafeSet[T] {
	return &SafeSet[T]{set: NewUnsafeSet(elems...)}
}

// Add 添加元素到集合
func (own *SafeSet[T]) Add(elems ...T) {
	own.lock.Lock()
	own.set.Add(elems...)
	own.lock.Unlock()
}

// Delete 从集合中删除元素
func (own *SafeSet[T]) Delete(elems ...T) {
	own.lock.Lock()
	own.set.Delete(elems...)
	own.lock.Unlock()
}

// HasAll 判断所有指定元素是否存在于集合
func (own *SafeSet[T]) HasAll(elems ...T) bool {
	own.lock.RLock()
	ok := own.set.HasAll(elems...)
	own.lock.RUnlock()
	return ok
}

// HasAny 判断任一指定元素是存在于集合
func (own *SafeSet[T]) HasAny(elems ...T) bool {
	own.lock.RLock()
	ok := own.set.HasAny(elems...)
	own.lock.RUnlock()
	return ok
}

// GetLength 获取集合长度
func (own *SafeSet[T]) GetLength() int {
	own.lock.RLock()
	length := own.set.GetLength()
	own.lock.RUnlock()
	return length
}

// GetElements 获取集合的所有元素
func (own *SafeSet[T]) GetElements() []T {
	own.lock.RLock()
	elems := own.set.GetElements()
	own.lock.RUnlock()
	return elems
}

// GetMap 获取集合的字典格式
func (own *SafeSet[T]) GetMap() map[T]struct{} {
	own.lock.RLock()
	elems := own.set.GetMap()
	own.lock.RUnlock()
	return elems
}

// IsEmpty 判断集合是否为空
func (own *SafeSet[T]) IsEmpty() bool {
	return own.GetLength() == 0
}

// IsEqualTo 判断两集合的元素是否完全相同
func (own *SafeSet[T]) IsEqualTo(other Set[T]) bool {
	own.lock.RLock()
	ok := own.set.IsEqualTo(other)
	own.lock.RUnlock()
	return ok
}

// IsSubsetOf 判断当前集合是否是指定集合的子集
func (own *SafeSet[T]) IsSubsetOf(other Set[T]) bool {
	own.lock.RLock()
	ok := own.set.IsSupersetOf(other)
	own.lock.RUnlock()
	return ok
}

// IsSupersetOf 判断当前集合是否为指定集合的超集
func (own *SafeSet[T]) IsSupersetOf(other Set[T]) bool {
	own.lock.RLock()
	ok := own.set.IsSupersetOf(other)
	own.lock.RUnlock()
	return ok
}

// Unite 求并集（不修改原集合，生成一个新的集合）
func (own *SafeSet[T]) Unite(other Set[T]) Set[T] {
	own.lock.RLock()
	set := own.set.Unite(other)
	own.lock.RUnlock()
	return set
}

// Intersect 求交集（不修改原集合，生成一个新的集合）
func (own *SafeSet[T]) Intersect(other Set[T]) Set[T] {
	own.lock.RLock()
	set := own.set.Intersect(other)
	own.lock.RUnlock()
	return set
}

// Complement 求补集（不修改原集合，生成一个新的集合）
func (own *SafeSet[T]) Complement(other Set[T]) Set[T] {
	own.lock.RLock()
	set := own.set.Complement(other)
	own.lock.RUnlock()
	return set
}

// Range 遍历并获取每个元素
func (own *SafeSet[T]) Range(fn func(T)) {
	own.lock.RLock()
	own.set.Range(fn)
	own.lock.RUnlock()
}

// Filter 过滤集合，并返回过滤的元素
func (own *SafeSet[T]) Filter(fn func(T) bool) []T {
	own.lock.Lock()
	elems := own.set.Filter(fn)
	own.lock.Unlock()
	return elems
}

// Clone 克隆当前集合
func (own *SafeSet[T]) Clone() Set[T] {
	own.lock.Lock()
	elems := NewSafeSet(own.GetElements()...)
	own.lock.Unlock()
	return elems
}

func (own *SafeSet[T]) Clear() {
	own.lock.Lock()
	own.set.Clear()
	own.lock.Unlock()
}
